package 时间类

import (
	"time"
)

// Now returns a Carbon instance for now.
// 当前
func X创建并按当前时间(时区 ...string) *Carbon {
	c := X创建()
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否有错误() {
		return c
	}
	if X是否为测试时间() {
		return frozenNow.testNow
	}
	c.time = time.Now().In(c.loc)
	return c
}

// Tomorrow returns a Carbon instance for tomorrow.
// 明天
func X创建并按明天时间(时区 ...string) *Carbon {
	c := X创建()
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否有错误() {
		return c
	}
	return X创建并按当前时间(c.X取时区位置()).X取副本().X增加1天()
}

// Yesterday returns a Carbon instance for yesterday.
// 昨天
func X创建并按昨天时间(时区 ...string) *Carbon {
	c := X创建()
	if len(时区) > 0 {
		c.loc, c.X错误 = parseTimezone(时区[0])
	}
	if c.X是否有错误() {
		return c
	}
	return X创建并按当前时间(c.X取时区位置()).X取副本().X减少1天()
}

// AddDuration adds duration.
// 按照时长增加时间,支持整数/浮点数和符号ns(纳秒)、us(微妙)、ms(毫秒)、s(秒)、m(分钟)、h(小时)的组合
func (c *Carbon) X增加时长(时长 string) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	td, err := parseDuration(时长)
	if err != nil {
		c.X错误 = err
		return c
	}
	c.time = c.X取Gosdk时间().Add(td)
	return c
}

// SubDuration subtracts duration.
// 按照时长减少时间,支持整数/浮点数和符号ns(纳秒)、us(微妙)、ms(毫秒)、s(秒)、m(分钟)、h(小时)的组合
func (c *Carbon) X减少时长(时长 string) *Carbon {
	return c.X增加时长("-" + 时长)
}

// AddCenturies adds some centuries.
// N 个世纪后
func (c *Carbon) X增加N个世纪(世纪 int) *Carbon {
	return c.X增加N年(世纪 * X常量_数字_每世纪100年)
}

// AddCenturiesNoOverflow adds some centuries without overflowing month.
// N 个世纪后(月份不溢出)
func (c *Carbon) X增加N个世纪并不溢出月份(世纪 int) *Carbon {
	return c.X增加N年并不溢出月份(世纪 * X常量_数字_每世纪100年)
}

// AddCentury adds one century.
// 1 个世纪后
func (c *Carbon) X增加1个世纪() *Carbon {
	return c.X增加N个世纪(1)
}

// AddCenturyNoOverflow adds one century without overflowing month.
// 1 个世纪后(月份不溢出)
func (c *Carbon) X增加1个世纪并不溢出月份() *Carbon {
	return c.X增加N个世纪并不溢出月份(1)
}

// SubCenturies subtracts some centuries.
// N 个世纪前
func (c *Carbon) X减少N个世纪(世纪 int) *Carbon {
	return c.X减少N年(世纪 * X常量_数字_每世纪100年)
}

// SubCenturiesNoOverflow subtracts some centuries without overflowing month.
// N 个世纪前(月份不溢出)
func (c *Carbon) X减少N个世纪并不溢出月份(世纪 int) *Carbon {
	return c.X减少N年并不溢出月份(世纪 * X常量_数字_每世纪100年)
}

// SubCentury subtracts one century.
// 1 个世纪前
func (c *Carbon) X减少1个世纪() *Carbon {
	return c.X减少N个世纪(1)
}

// SubCenturyNoOverflow subtracts one century without overflowing month.
// 1 个世纪前(月份不溢出)
func (c *Carbon) X减少1个世纪并不溢出月份() *Carbon {
	return c.X减少N个世纪并不溢出月份(1)
}

// AddDecades adds some decades.
// N 个年代后
func (c *Carbon) X增加N个年代(年代 int) *Carbon {
	return c.X增加N年(年代 * X常量_数字_每十年10年)
}

// AddDecadesNoOverflow adds some decades without overflowing month.
// N 个年代后(月份不溢出)
func (c *Carbon) X增加N个年代并不溢出月份(年代 int) *Carbon {
	return c.X增加N年并不溢出月份(年代 * X常量_数字_每十年10年)
}

// AddDecade adds one decade.
// 1 个年代后
func (c *Carbon) X增加1个年代() *Carbon {
	return c.X增加N个年代(1)
}

// AddDecadeNoOverflow adds one decade without overflowing month.
// 1 个年代后(月份不溢出)
func (c *Carbon) X增加1个年代并不溢出月份() *Carbon {
	return c.X增加N个年代并不溢出月份(1)
}

// SubDecades subtracts some decades.
// N 个年代后
func (c *Carbon) X减少N个年代(年代 int) *Carbon {
	return c.X减少N年(年代 * X常量_数字_每十年10年)
}

// SubDecadesNoOverflow subtracts some decades without overflowing month.
// N 个年代后(月份不溢出)
func (c *Carbon) X减少N个年代并不溢出月份(年代 int) *Carbon {
	return c.X减少N年并不溢出月份(年代 * X常量_数字_每十年10年)
}

// SubDecade subtracts one decade.
// 1 个年代后
func (c *Carbon) X减少1个年代() *Carbon {
	return c.X减少N个年代(1)
}

// SubDecadeNoOverflow subtracts one decade without overflowing month.
// 1 个年代后(月份不溢出)
func (c *Carbon) X减少1个年代并不溢出月份() *Carbon {
	return c.X减少N个年代并不溢出月份(1)
}

// AddYears adds some years.
// N 年后
func (c *Carbon) X增加N年(年 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	c.time = c.X取Gosdk时间().AddDate(年, 0, 0)
	return c
}

// AddYearsNoOverflow adds some years without overflowing month.
// N 年后(月份不溢出)
func (c *Carbon) X增加N年并不溢出月份(年 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	nanosecond := c.X取纳秒()
	year, month, day, hour, minute, second := c.X取年月日时分秒()
	// 获取N年后本月的最后一天
	lastYear, lastMonth, lastDay := create(year+年, month+1, 0, hour, minute, second, nanosecond, c.X取时区位置()).X取年月日()
	if day > lastDay {
		day = lastDay
	}
	return create(lastYear, lastMonth, day, hour, minute, second, nanosecond, c.X取时区位置())
}

// AddYear adds one year.
// 1 年后
func (c *Carbon) X增加1年() *Carbon {
	return c.X增加N年(1)
}

// AddYearNoOverflow adds one year without overflowing month.
// 1 年后(月份不溢出)
func (c *Carbon) X增加1年并不溢出月份() *Carbon {
	return c.X增加N年并不溢出月份(1)
}

// SubYears subtracts some years.
// N 年前
func (c *Carbon) X减少N年(年 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	return c.X增加N年(-年)
}

// SubYearsNoOverflow subtracts some years without overflowing month.
// N 年前(月份不溢出)
func (c *Carbon) X减少N年并不溢出月份(年 int) *Carbon {
	return c.X增加N年并不溢出月份(-年)
}

// SubYear subtracts one year.
// 1 年前
func (c *Carbon) X减少1年() *Carbon {
	return c.X减少N年(1)
}

// SubYearNoOverflow subtracts one year without overflowing month.
// 1 年前(月份不溢出)
func (c *Carbon) X减少1年并不溢出月份() *Carbon {
	return c.X减少N年并不溢出月份(1)
}

// AddQuarters adds some quarters
// N 个季度后
func (c *Carbon) X增加N个季度(季度 int) *Carbon {
	return c.X增加N个月(季度 * X常量_数字_每季度3月)
}

// AddQuartersNoOverflow adds quarters without overflowing month.
// N 个季度后(月份不溢出)
func (c *Carbon) X增加N个季度并不溢出月份(季度 int) *Carbon {
	return c.X增加N个月并不溢出月份(季度 * X常量_数字_每季度3月)
}

// AddQuarter adds one quarter
// 1 个季度后
func (c *Carbon) X增加1个季度() *Carbon {
	return c.X增加N个季度(1)
}

// AddQuarterNoOverflow adds one quarter without overflowing month.
// 1 个季度后(月份不溢出)
func (c *Carbon) X增加1个季度并不溢出月份() *Carbon {
	return c.X增加N个季度并不溢出月份(1)
}

// SubQuarters subtracts some quarters.
// N 个季度前
func (c *Carbon) X减少N个季度(季度 int) *Carbon {
	return c.X增加N个季度(-季度)
}

// SubQuartersNoOverflow subtracts some quarters without overflowing month.
// N 个季度前(月份不溢出)
func (c *Carbon) X减少N个季度并不溢出月份(季度 int) *Carbon {
	return c.X增加N个月并不溢出月份(-季度 * X常量_数字_每季度3月)
}

// SubQuarter subtracts one quarter.
// 1 个季度前
func (c *Carbon) X减少1个季度() *Carbon {
	return c.X减少N个季度(1)
}

// SubQuarterNoOverflow subtracts one quarter without overflowing month.
// 1 个季度前(月份不溢出)
func (c *Carbon) X减少1个季度并不溢出月份() *Carbon {
	return c.X减少N个季度并不溢出月份(1)
}

// AddMonths adds some months.
// N 个月后
func (c *Carbon) X增加N个月(月 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	c.time = c.X取Gosdk时间().AddDate(0, 月, 0)
	return c
}

// AddMonthsNoOverflow adds some months without overflowing month.
// N 个月后(月份不溢出)
func (c *Carbon) X增加N个月并不溢出月份(月 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	nanosecond := c.X取纳秒()
	year, month, day, hour, minute, second := c.X取年月日时分秒()
	// 获取N月后的最后一天
	lastYear, lastMonth, lastDay := create(year, month+月+1, 0, hour, minute, second, nanosecond, c.X取时区位置()).X取年月日()
	if day > lastDay {
		day = lastDay
	}
	return create(lastYear, lastMonth, day, hour, minute, second, nanosecond, c.X取时区位置())
}

// AddMonth adds one month.
// 1 个月后
func (c *Carbon) X增加1个月() *Carbon {
	return c.X增加N个月(1)
}

// AddMonthNoOverflow adds one month without overflowing month.
// 1 个月后(月份不溢出)
func (c *Carbon) X增加1个月并不溢出月份() *Carbon {
	return c.X增加N个月并不溢出月份(1)
}

// SubMonths subtracts some months.
// N 个月前
func (c *Carbon) X减少N个月(月 int) *Carbon {
	return c.X增加N个月(-月)
}

// SubMonthsNoOverflow subtracts some months without overflowing month.
// N 个月前(月份不溢出)
func (c *Carbon) X减少N个月并不溢出月份(月 int) *Carbon {
	return c.X增加N个月并不溢出月份(-月)
}

// SubMonth subtracts one month.
// 1 个月前
func (c *Carbon) X减少1个月() *Carbon {
	return c.X减少N个月(1)
}

// SubMonthNoOverflow subtracts one month without overflowing month.
// 1 个月前(月份不溢出)
func (c *Carbon) X减少1个月并不溢出月份() *Carbon {
	return c.X减少N个月并不溢出月份(1)
}

// AddWeeks adds some weeks.
// N 周后
func (c *Carbon) X增加N周(周 int) *Carbon {
	return c.X增加N天(周 * X常量_数字_每周7天)
}

// AddWeek adds one week.
// 1 周后
func (c *Carbon) X增加1周() *Carbon {
	return c.X增加N周(1)
}

// SubWeeks subtracts some weeks.
// N 周前
func (c *Carbon) X减少N周(周 int) *Carbon {
	return c.X减少N天(周 * X常量_数字_每周7天)
}

// SubWeek subtracts one week.
// 1 周前
func (c *Carbon) X减少1周() *Carbon {
	return c.X减少N周(1)
}

// AddDays adds some days.
// N 天后
func (c *Carbon) X增加N天(天 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	c.time = c.X取Gosdk时间().AddDate(0, 0, 天)
	return c
}

// AddDay adds one day.
// 1 天后
func (c *Carbon) X增加1天() *Carbon {
	return c.X增加N天(1)
}

// SubDays subtracts some days.
// N 天前
func (c *Carbon) X减少N天(天 int) *Carbon {
	return c.X增加N天(-天)
}

// SubDay subtracts one day.
// 1 天前
func (c *Carbon) X减少1天() *Carbon {
	return c.X减少N天(1)
}

// AddHours adds some hours.
// N 小时后
func (c *Carbon) X增加N小时(小时 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	td := X时长(小时) * time.Hour
	c.time = c.X取Gosdk时间().Add(td)
	return c
}

// AddHour adds one hour.
// 1 小时后
func (c *Carbon) X增加1小时() *Carbon {
	return c.X增加N小时(1)
}

// SubHours subtracts some hours.
// N 小时前
func (c *Carbon) X减少N小时(小时 int) *Carbon {
	return c.X增加N小时(-小时)
}

// SubHour subtracts one hour.
// 1 小时前
func (c *Carbon) X减少1小时() *Carbon {
	return c.X减少N小时(1)
}

// AddMinutes adds some minutes.
// N 分钟后
func (c *Carbon) X增加N分钟(分 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	td := X时长(分) * time.Minute
	c.time = c.X取Gosdk时间().Add(td)
	return c
}

// AddMinute adds one minute.
// 1 分钟后
func (c *Carbon) X增加1分钟() *Carbon {
	return c.X增加N分钟(1)
}

// SubMinutes subtracts some minutes.
// N 分钟前
func (c *Carbon) X减少N分钟(分 int) *Carbon {
	return c.X增加N分钟(-分)
}

// SubMinute subtracts one minute.
// 1 分钟前
func (c *Carbon) X减少1分钟() *Carbon {
	return c.X减少N分钟(1)
}

// AddSeconds adds some seconds.
// N 秒钟后
func (c *Carbon) X增加N秒(秒 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	td := X时长(秒) * time.Second
	c.time = c.X取Gosdk时间().Add(td)
	return c
}

// AddSecond adds one second.
// 1 秒钟后
func (c *Carbon) X增加1秒() *Carbon {
	return c.X增加N秒(1)
}

// SubSeconds subtracts some seconds.
// N 秒钟前
func (c *Carbon) X减少N秒(秒 int) *Carbon {
	return c.X增加N秒(-秒)
}

// SubSecond subtracts one second.
// 1 秒钟前
func (c *Carbon) X减少1秒() *Carbon {
	return c.X减少N秒(1)
}

// AddMilliseconds adds some milliseconds.
// N 毫秒后
func (c *Carbon) X增加N毫秒(毫秒 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	td := X时长(毫秒) * time.Millisecond
	c.time = c.X取Gosdk时间().Add(td)
	return c
}

// AddMillisecond adds one millisecond.
// 1 毫秒后
func (c *Carbon) X增加1毫秒() *Carbon {
	return c.X增加N毫秒(1)
}

// SubMilliseconds subtracts some milliseconds.
// N 毫秒前
func (c *Carbon) X减少N毫秒(毫秒 int) *Carbon {
	return c.X增加N毫秒(-毫秒)
}

// SubMillisecond subtracts one millisecond.
// 1 毫秒前
func (c *Carbon) X减少1毫秒() *Carbon {
	return c.X减少N毫秒(1)
}

// AddMicroseconds adds some microseconds.
// N 微秒后
func (c *Carbon) X增加N微秒(微妙 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	td := X时长(微妙) * time.Microsecond
	c.time = c.X取Gosdk时间().Add(td)
	return c
}

// AddMicrosecond adds one microsecond.
// 1 微秒后
func (c *Carbon) X增加1微秒() *Carbon {
	return c.X增加N微秒(1)
}

// SubMicroseconds subtracts some microseconds.
// N 微秒前
func (c *Carbon) X减少N微秒(微妙 int) *Carbon {
	return c.X增加N微秒(-微妙)
}

// SubMicrosecond subtracts one microsecond.
// 1 微秒前
func (c *Carbon) X减少1微秒() *Carbon {
	return c.X减少N微秒(1)
}

// AddNanoseconds adds some nanoseconds.
// N 纳秒后
func (c *Carbon) X增加N纳秒(纳秒 int) *Carbon {
	if c.X是否为无效时间() {
		return c
	}
	td := X时长(纳秒) * time.Nanosecond
	c.time = c.X取Gosdk时间().Add(td)
	return c
}

// AddNanosecond adds one nanosecond.
// 1 纳秒后
func (c *Carbon) X增加1纳秒() *Carbon {
	return c.X增加N纳秒(1)
}

// SubNanoseconds subtracts some nanoseconds.
// N 纳秒前
func (c *Carbon) X减少N纳秒(纳秒 int) *Carbon {
	return c.X增加N纳秒(-纳秒)
}

// SubNanosecond subtracts one nanosecond.
// 1 纳秒前
func (c *Carbon) X减少1纳秒() *Carbon {
	return c.X减少N纳秒(1)
}
